JavaScript
part 15/19 · 71.2 KB total
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
l'ensemble des variables non locales qu'elle a capturé, soit par valeur
(conservation d'une copie de chaque donnée liée aux variables non
locales), soit par référence (conservation d'une référence à chaque
donnée liée aux variables non locales). Comme en JavaScript toutes les
variables sont de type référence (cf. la section
Liaison des identifiants), JavaScript n'utilise que la capture par
référence — ce qui correspond en C++ 11 à la syntaxe [&](…) { … }; —, et
la durée de vie des variables non locales capturées par une fonction est
étendue à la durée de vie de la fonction — ce qui n'est pas le cas en
C++ 11, quel que soit le type de capture :
function maFonction() {
var maVariable = 4; // variable parente
return function () {
alert(maVariable);
}
}
var maFermeture = maFonction(); // capture de la variable parente par
référence
maFermeture(); // affiche 4
Expressions de fonctions immédiatement invoquées
Jusqu'à ECMAScript 6, JavaScript ne proposait pas nativement de portée
des variables au niveau des blocs (pas de mots-clé let ou const), ni de
modules. Pour éviter de polluer l'espace global, une méthode consistait
à encapsuler son code dans une fonction pour s'appuyer sur la portée des
variables qui a lieu au niveau des fonctions en JavaScript, puis à
invoquer cette fonction juste après. Pour regrouper les deux étapes
(définition de la fonction et invocation) et ne pas ajouter un nom de
fonction supplémentaire dans l'espace global, le langage permet les
expressions de fonctions immédiatement invoquées (EFII ; en anglais
immediately-invoked function expressions, IIFE)cite-ref-30[30].
Plusieurs syntaxes sont possibles pour ce type d'expression, les plus
répandues étant :
pour sa lisibilité)cite-ref-31[31] ;
• (function (…) { … })(…);
L'opérateur d'invocation de fonction () à la fin permet l'exécution
immédiate de la fonction. Les parenthèses en gras indiquent à
l'analyseur syntaxique qu'elles contiennent une expression, car en
JavaScript les parenthèses ne peuvent pas contenir de déclaration.
Autrement, dans la plupart des situations, le mot clé function est
traité comme une déclaration de fonction, et pas comme une expression de
fonction. Il existe d'autres façons pour forcer une expression de
fonction :
• !function (…) { … }(…);
• ~function (…) { … }(…);
• -function (…) { … }(…);
• +function (…) { … }(…);
Dans les contextes où une expression est attendue il n'est pas
nécessaire d'utiliser les parenthèses en gras :
• var maVariable = function (…) { … }(…);
• true && function (…) { … }(…);
• 0, function (…) { … }(…);
Une utilisation importante des expressions de fonctions immédiatement
invoquées est pour la création de modules. Les modules permettent à la
fois de rassembler des propriétés et des méthodes dans un espace de nom
et de rendre certains membres privés :
var compteur = (function () {
var i = 0; // propriété privée
return { // méthodes publiques
obtenir: function () {
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────